/**
 * @Copyright:Copyright (c) 1992 - 2015
 * @Company: TengTong
 */
package com.tengtong.duang.commons.collections;

import java.io.File;
import java.util.Arrays;
import java.util.List;
import java.util.Optional;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Stream;

import com.tengtong.duang.commons.utils.ReflectUtils;

/**
 * 数组包装类，目标是提供方便的 Stream 操作
 * 
 * @author jai
 *
 */
public class ArrayWrapper<T> {

	/**
	 * 一个空数组
	 */
	public static final ArrayWrapper EMPTY_ARRAY = new ArrayWrapper(new Object[0]);
	
	private final T[] arrays;
	
	public ArrayWrapper(final T[] arrays){
		this.arrays = arrays;
	}
	
	/**
	 * 静态创建方法
	 * @param arrays
	 * @return
	 */
	public static <T> ArrayWrapper<T> wrapper(T[] arrays){
		return new ArrayWrapper<T>(arrays);
	}
	
	//public static <T>
	
	/**
	 * 返回本类所包装的那个数组
	 * @return
	 */
	public final T[] toArrays(){
		return this.arrays;
	}
	
	/**
	 * 数组非空就做
	 *
	 * @param consumer
	 */
	public final void ifPresent(Consumer<T[]> consumer){
		Optional.of(arrays).ifPresent(consumer);
	}
	
	/**
	 * 做，并且如果有异常的话，就将异常转为 RuntimeException
	 *
	 * @param consumer
	 */
	public final void doOrToRuntimeException(Consumer<T[]> consumer){
		try{
			consumer.accept(arrays);
		}catch(Exception e){
			throw ReflectUtils.toRuntimeException(e);
		}
	}
	
	/**
	 * 逐个迭代
	 * @param action
	 */
	public void forEach(Consumer<? super T> action){
		if(notNullOrEmpty()){
			Stream.of(arrays).forEach(action);
		}
	}
	
	/**
	 * for(i, i < size; i++) 迭代
	 * 
	 * @param action
	 */
	public void forEach(BiConsumer<? super T, Integer> action){
		if(notNullOrEmpty() && action != null){
			for(int i=0; i<arrays.length; i++){
				action.accept(arrays[i], i);
			}
		}
	}
	
	/**
	 * 提供一个过滤器
	 * 
	 * @param predicate
	 * @return
	 */
	public Stream<T> filter(Predicate<? super T> predicate){
		return Stream.of(arrays).filter(predicate);
	}
	
	/**
	 * 提供一个 map 方法
	 * @param mapper
	 * @return
	 */
	public <R> Stream<R> map(Function<? super T,? extends R> mapper){
		return Stream.of(arrays).map(mapper);
	}
	
	/**
	 * 提供一个  flatMap 方法
	 * @param mapper
	 * @return
	 */
	public <R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper){
		return Stream.of(arrays).flatMap(mapper);
	}
	
	/**
	 * 合并成一个字符串
	 * @return
	 */
	public String deepToString(){
		return Arrays.deepToString(arrays);
	}
	
	/**
	 * 使用分隔符 delimiter 合并成一个字符串
	 * @return
	 */
	public String deepToString(String delimiter){
		StringBuilder sb = new StringBuilder();
		forEach(x->{
			if(sb.length() > 0){
				sb.append(delimiter);
			}
			sb.append(x);
		});
		
		return sb.toString();
	}
	
	/**
	 * 转成 List
	 * 
	 * @return
	 */
	public List<T> toList(){
		return Arrays.asList(arrays);
	}
	
	/**
	 * 非空
	 * @return
	 */
	public boolean notNullOrEmpty(){
		return arrays != null && arrays.length > 0;
	}
		
}
